import store from '@/store'
import config from '@/util/config.js';

// 工具库
export const util = {

	//	配置参数
	config,

	// 正则
	reg: {
		// 手机号
		tel: /^1[3-9]\d{9}$/,
	},

	// 弹窗
	alert(obj) {
		// 没值
		if (obj == null || obj == undefined) return

		//	这个地方说白了就是 如果只是想提示一句话一个文本的话 就只是弹个小tips
		if (typeof obj == "string" || typeof obj == "number") {
			uni.showToast({
				'title': "" + obj + "",
				'icon': 'none',
				duration: 3000,
			});
			return
		}

		//	标题
		obj.title = obj.title ? obj.title : ""

		//	提示内容
		obj.value = obj.value ? obj.value : ""

		//	跳转页面
		obj.url = obj.url ? obj.url : ""

		//	确定文本
		obj.confirmText = obj.confirmText ? obj.confirmText : "确定"

		//	取消按钮
		obj.cancel = obj.cancel === false ? false : true

		//	是否关闭当前页面
		obj.close = obj.close ? obj.close : false

		//	取消文本
		obj.cancelText = obj.cancelText ? obj.cancelText : "取消"

		// 返回 Promise 对象
		return new Promise((resolve, reject) => {
			//	调起
			uni.showModal({
				title: obj.title,
				content: obj.value,
				confirmText: obj.confirmText,
				showCancel: obj.cancel,
				cancelText: obj.cancelText,
				success: res => {
					obj.success ? obj.success(res) : () => {}
					resolve(res)
				},
				fail: err => {
					obj.fail ? obj.fail : () => {}
					reject(err)
				}
			})
		})
	},

	//	上传文件
	upload(obj) {
		console.log(obj);
		//	使用promise写请求,一个函数两种回调
		return new Promise((resolve, reject) => {
			//	接口地址
			obj.url = obj.url ? obj.url : util.config.upload_file_api
			//	文件
			obj.file = obj.file ? obj.file : ""
			//	附加数据
			obj.data = obj.data ? obj.data : {}
			//	设置token
			obj.data.token = uni.getStorageSync('userinfo').token
			//	打开loading效果
			uni.showLoading({
				title: "正在上传",
			})

			//	上传
			uni.uploadFile({
				url: util.config.host + obj.url,
				filePath: obj.file,
				name: 'file',
				formData: obj.data,
				dataType: 'json',
				// 成功
				success: (res) => {
					//	关闭loading效果
					uni.hideLoading()
					const rs = JSON.parse(res.data);
					if (rs.code == 1) {
						obj.success ? obj.success(rs.data) : ''
						resolve(rs.data);
					} else {
						util.alert(rs.msg)
					}
				},
				// 失败
				fail: (res) => {
					//	关闭loading效果
					uni.hideLoading()
					//	错误
					obj.fail ? obj.fail(res.data) : ''
					//	
					reject(res)
				}
			})
		})
	},

	//	发送网络请求
	request(params) {

		//	返回方法
		return new Promise((resolve, reject) => {

			let host = params.host ? params.host : util.config.host;

			if (!params.url) {
				util.alert('缺少url')
				return
			}

			//	请求地址
			var url = host + (params.url ? params.url : '/api/index/index');

			//	是否打开加载效果
			if (params.load) {
				uni.showLoading({
					title: "加载中",
				})
			}

			// application/json 请求数组配置
			params.header = params.header ? params.header : {
				"Content-Type": "application/x-www-form-urlencoded",
			}

			// 设置默认token
			params.header.token = uni.getStorageSync('userinfo').token

			//	发起网络请求
			uni.request({
				url: url, // 请求地址
				method: params.type ? params.type : "POST", // 请求方式 get/post
				sslVerify: false, // 是否开启SSL验证
				data: params.data, // 请求参数
				header: params.header, // header请求头
				dataType: 'json', // 数据类型
				success(res) { // 请求成功返回

					// params.load && uni.hideLoading()
					if (params.load) { // 关闭加载效果
						uni.showLoading({
							title: "加载中",
						})
						uni.hideLoading()
					}

					if (res.data.code === 401) { // 未登录
						//util.alert('请先登录');//2024年5月12日15:34:31
						// 退出登录
						util.logout();
						reject(res.data);
						return
					}
					params.success ? params.success(res.data) :
						function() {}; // 嵌套式回调
					/* if (res.data.code === 1) {
						resolve(res.data); // 链式回调
					} else if (res.data.code === 2) {
						// util.alert(res.data.msg)
						resolve(res.data);
					} */
					resolve(res.data);
				},
				fail(res) { // 请求失败返回

					if (params.load) { // 关闭加载效果
						uni.hideLoading()
					}
					util.alert('暂无网络，请稍后重试')
					params.fail ? params.fail(res) : function() {}; // 嵌套式回调
					reject(res) //	链式回调
				},
				complete() {
					params.complete ? params.complete() :
						function() {}; //	嵌套式回调
				},
			})
		})
	},

	// 获取数据 直接赋值
	getInfo(all, obj) {

		obj.header = obj.header ? obj.header : '';

		// 请求类型
		obj.type = obj.type ? obj.type : '';

		// 接口地址
		obj.url = obj.url ? obj.url : '';

		// 接口参数
		obj.data = obj.data ? obj.data : {};

		// 赋值 
		obj.to = obj.to ? obj.to : '';

		// alert
		obj.alert = obj.alert ? obj.alert : '';

		// 域名 true 后续自动加 '' 不需要加
		obj.host = obj.host ? obj.host : '';

		// 是否加载
		// obj.load = obj.load ? obj.load : '';
		return new Promise((resolve, reject) => {

			// 请求网络接口
			util.request({
				header: obj.header,
				type: obj.type,
				host: obj.host,
				load: obj.load == false ? obj.load : true,
				url: obj.url,
				data: obj.data,
				success(rs) {
					if (rs.code == 200) {

						// 赋值
						if (obj.to) {

							let pageNum = obj.data.pageNo ? obj.data
								.pageNo : obj.data.pageNum;
							pageNum = obj.data.page ? obj.data.page :
								pageNum;

							// 分页
							if (pageNum) {
								let Data = rs.data ? rs.data : rs.result
									.records;

								// 数据为空 
								if (!Data) {
									all[obj.to] = [];
									// all[obj.to] = rs.data ? rs.data: rs.result.records;
									obj.success ? obj.success(rs) :
										function() {};
									return
								}
								// 数据 no is Array 
								if (!Data instanceof Array) {
									that.alert('Data 不是 Array 类型')
									obj.success ? obj.success(rs) :
										function() {};
									return
								}

								if (pageNum == 1) {
									all[obj.to] = Data;
								} else {
									all[obj.to].push(...Data);
								}

								// 判断数据返回足够 赋值是否可以加载下一页
								if (Data[obj.data.pageSize - 1]) {
									all.pages.Load = true;
								} else {
									all.pages.Load = false;
								}

								obj.success ? obj.success(rs) :
									function() {};
							} else { // 不分页
								all[obj.to] = rs.result;
								obj.success ? obj.success(rs) :
									function() {};
							}
						}

						// 开启返回数据
						obj.success ? obj.success(rs) : function() {};
						resolve(rs);
					} else {

						// obj.alertClose = obj.alertClose ? false : true;
						// // obj.alertClose true: 弹窗提示 false: 无提示
						// if (obj.alertClose) {
						// 	let value = rs.msg ? rs.msg : rs.message
						// 	util.alert(value)
						// }

						obj.successCodeElse ? obj.successCodeElse(rs) :
							function() {};
						reject(rs);

					}

				},
				fail(rs) {
					obj.fail ? obj.fail(rs) : function() {};
					reject(rs);
				},
			});
		})
	},

	//	替换图片的宽度为最大宽度100% (移动端解析html富文本专用)
	imgReplace(value, th) {
		let _self = this;

		if (!th) {
			value = value.replace(/<img src="/ig, '<img src="' + util.config.host);
		}
		return value.replace(/<p([\s\w"=\/\.:;]+)((?:(style="[^"]+")))/ig, '<p')
			.replace(/<p>/ig, '<p style="font-size: 15px; line-height: 25px;">')
			.replace(/<img([\s\w"-=\/\.:;]+)((?:(height="[^"]+")))/ig, '<img$1')
			.replace(/<img([\s\w"-=\/\.:;]+)((?:(width="[^"]+")))/ig, '<img$1')
			.replace(/<img([\s\w"-=\/\.:;]+)((?:(style="[^"]+")))/ig, '<img$1')
			.replace(/<img([\s\w"-=\/\.:;]+)((?:(alt="[^"]+")))/ig, '<img$1')
			.replace(/<img([\s\w"-=\/\.:;]+)/ig, '<img style="width: 100%;" $1')
	},

	//	微信小程序分享转发
	wxShare(obj) {
		//	获取加载的页面
		let pages = getCurrentPages()
		//	获取当前页面的对象
		let currentPage = pages[pages.length - 1]
		//	地址
		let url = "/pages/index/index";
		//	如果存在页面对象
		if (obj) {
			url = "/" + currentPage.route;
		}

		//	当前页面的参数
		let options = currentPage.options;

		//	如果已经登录
		if (uni.getStorageSync("userinfo")) {
			options.pid = uni.getStorageSync("userinfo")
				.id;
		}

		//	分享页面
		url = util.setUrl(url, options)

		//	分享参数
		let share = {
			path: url,
		}

		return currentPage.$vm.share ? currentPage.$vm.share : share
	},

	//	get参数拼接
	setParam(data) {
		// 初始路径
		let url = ''

		// 格式化
		if (!data) data = []

		// 遍历
		for (let [key, value] of Object.entries(data)) {
			url += `${key}=${value}&`
		}

		return url ? url : url.substring(1)
	},

	//	get参数拼接url
	setUrl(url, data) {
		let result = url += (url.indexOf('?') < 0 ? '?' : '&') + util.setParam(data)
		return result
	},

	//	倒计时
	countDownd(endtime) {
		if (!endtime) {
			return
		}

		endtime = Number(endtime)

		let timestamp = Date.parse(new Date()) / 1000

		if (endtime > 100000) {
			//	距离结束的秒数
			let time = (endtime - timestamp)
		} else {
			let time = endtime
		}

		// 获取天、时、分、秒
		let day = util.timeFormin(parseInt(time / (60 * 60 * 24)))
		let hou = util.timeFormin(parseInt(time % (60 * 60 * 24) / 3600))
		let min = util.timeFormin(parseInt(time % (60 * 60 * 24) % 3600 / 60))
		let sec = util.timeFormin(parseInt(time % (60 * 60 * 24) % 3600 % 60))

		let str = "";

		if (day) {
			str += day + "天"
		}

		if (hou || hou == 0) {
			if (hou > 9) {
				str += hou + ":"
			} else {
				str += "0" + hou + ":"
			}
		} else {
			str += "00:"
		}

		if (min || min == 0) {
			if (min > 9) {
				str += min + ":"
			} else {
				str += "0" + min + ":"
			}
		} else {
			str += "00:";
		}

		if (sec) {
			if (sec > 9) {
				str += sec;
			} else {
				str += "0" + sec
			}
		} else {
			str += "00"
		}

		return str
	},

	// 对二补齐
	toTwo(str) {
		// 格式化字符
		let num = String(Number(str));

		// 判断时间
		if (num.length < 2) {
			num = '0' + num;
		}

		// 返回时间
		return num;
	},

	//	格式化时间
	timeFormin(param) {
		return param < 0 ? 0 : param;
	},


	// 跳转
	//路径    参数     类型
	to(url, param, type) {

		if (!url) {
			util.alert("该功能尚未开放")
			return
		}

		type = type ?? "navigateTo"
		param = param ?? '';

		switch (type) {
			case "switchTab":
				uni.switchTab({
					url: util.setUrl(url, param),
				})
				break;
			case "redirectTo":
				uni.redirectTo({
					url: util.setUrl(url, param),
				})
				break;
			case "navigateTo":
				uni.navigateTo({
					url: util.setUrl(url, param),
					fail(e) {
						console.log("路径打不开", e.errMsg);
						util.alert("该功能尚未开放")
					}
				})
				break;
			case "reLaunch":
				uni.reLaunch({
					url: util.setUrl(url, param),
				})
				break;
		}
	},
	// 返回上一页
	return_page() {

		// 获取当前路由
		let routeList = getCurrentPages();
		// let route = routeList[routeList.length-1].route;
		// console.log(routeList,route);
		if (routeList.length < 2) { // 返回首页
			util.index();
		} else {
			uni.navigateBack();
		}
	},

	// 返回首页
	index() {
		// 项目首页
		uni.reLaunch({
			url: '/pages/index/index',
		})
	},

	// 获取用户绑定手机号
	getTel(obj) {
		console.log('前端可以实现功能，但无法上传，不可出现秘钥明文，所以需要后台请求接口获取');
		return
		// 
		let host = "https://api.weixin.qq.com"
		let url = "/cgi-bin/token";
		let data = {
			grant_type: "client_credential", // string	是	填写 client_credential
			appid: util.config
				.appId, // string	是	小程序唯一凭证，即 AppID，可在「微信公众平台 - 设置 - 开发设置」页中获得。（需要已经成为开发者，且帐号没有异常状态）
			secret: util.config.secret, // string	是	小程序唯一凭证密钥，即 AppSecret，获取方式同 appid
		};

		util.request({
			type: 'get',
			load: true,
			host,
			url,
			data,
		}).then(rs => {
			// console.log('获取access_token ',rs.access_token);
			util.request({
				host,
				header: {
					'Content-Type': 'application/json'
				},
				load: true,
				url: '/wxa/business/getuserphonenumber?access_token=' + rs.access_token,
				data: {
					code: obj.code
				},
			}).then(res => {
				if (res.errcode == 0) {
					obj.success ? obj.success(res.phone_info.phoneNumber) :
						function() {};
				}
			})
		})
	},

	// 获取新的 时间格式 s 转换时间
	getTime_s(s, type, text) {

		if (!s) return '00:00';

		let s_text = '';
		let m_text = '';
		switch (type) {
			case ':':
				s_text = ''
				m_text = ':'
				break;
			default:
				s_text = ' 秒'
				m_text = ' 分钟'
				break;
		}

		let h = '';
		if (s < 10) {
			if (s_text == ' 秒') {
				return '0' + s + s_text
			}
			if (text == 's') {
				return '0' + s + s_text
			}
			return '00' + m_text + '0' + s + s_text
		}

		if (s < 60) {
			if (s_text == ' 秒') {
				return s + s_text
			}
			if (text == 's') {
				return s + s_text
			}
			return '00' + m_text + s + s_text
		}

		if (s > 60 || s == 60) {
			// 取整
			h = Math.trunc(s / 60);
			s = s % 60;
			if (s) {
				if (s_text == ' 秒') {
					return h + m_text + util.getTime_s(s, type)
				} else {
					return h + m_text + util.getTime_s(s, type, 's')
				}
			} else {
				if (s_text == ' 秒') {
					return h + m_text
				} else {
					return h + m_text + '00';
				}
			}
		}
	},


	/**	transfer_time转换为日期格式
	 * data, 时间戳 为空则去当前时间戳
	 * add: '1' // 在时间戳的基础上加几天 let basetime = 24 * 60 * 60 * 1000;
	 * type: "月-日",
	 * layout: 'start', // start 开始时间 end 结束时间
	 */
	TimeType(obj) {

		// 24 小时时间戳
		let basetime = 24 * 60 * 60 * 1000;

		if (!obj || !obj.data) {
			// 获取完整的日期（默认格式）：
			// obj.data = new Date(); 
			obj.data = Date.now();
		}
		if (obj.add) { // 在时间戳的基础上加几天
			obj.data = obj.data + basetime * Number(obj.add);
		}

		let timestamp;
		//时间戳为10位需*1000，时间戳为13位的话不需乘1000
		if (obj.data.toString().length == 10) {
			timestamp = Number(obj.data) * 1000;
		} else {
			timestamp = Number(obj.data);
		}
		var datetime = new Date(timestamp);
		// console.log(datetime);

		let Y = datetime.getFullYear();
		let M = (datetime.getMonth() + 1 < 10 ? '0' + (datetime.getMonth() + 1) : datetime.getMonth() + 1);
		let D = datetime.getDate() < 10 ? '0' + datetime.getDate() : datetime.getDate();
		let Z = datetime.getDay(); // 周
		let h = datetime.getHours();
		let m = datetime.getMinutes();
		let s = datetime.getSeconds();
		let retTime = '';

		// type  不同格式 
		// Y-M-D 年月日
		switch (obj.type) {
			case 'Y-M-D':
				retTime = Y + '-' + M + '-' + D;

				if (obj.layout == 'start') {
					retTime = Y + '-' + M + '-' + D + ' ' + '00:00:00';
				} else if (obj.layout == 'end') {
					retTime = Y + '-' + M + '-' + D + ' ' + '24:00:00';
				}
				break;

			case '月-日':
				retTime = M + '月' + D + '日';
				break;

			case '周':
				// 周列表
				let weekList = ['日', '一', '二', '三', '四', '五', '六']
				retTime = '周' + weekList[Z];
				break;

			case 'h':
				retTime = h
				break;

			default:
				retTime = Y + '-' + M + '-' + D + ' ' + h + ':' + m + ':' + s;
				break;
		}
		return retTime;
	},

	/**	ifDate 比较日期
	 * startTime 第一个日期 YYYY-MM-DD
	 * endTime 第二个日期 YYYY-MM-DD
	 * type '-'、'>'
	 */
	ifDate(startTime, endTime, type = '-') {
		if (!startTime || !endTime) {
			console.log('ifDate 函数 缺少参数');
			return false
		}

		let k1 = new Date(startTime)
		let k2 = new Date(endTime)

		switch (type) {
			case '-':
				return k2.getTime() - k1.getTime();
				break;

			case '>':
				return k1.getTime() > k2.getTime() ? true : false;
				break;

			default:
				return '';
				break;
		}
	},

	// 处理头像
	getImage(url_text, type) {
		// let img_url = '/static/no.png';
		let img_url = '/static/loading.gif';

		if (!url_text || url_text == 'null') {
			return img_url;
		}

		let arr = url_text.split(',');
		let url = arr[0];
		if (!url) {
			if (type == 'avatar') {
				return img_url;
			}
			return img_url;
		}

		// 遍历域名
		if (url.indexOf("http") > -1 || url == '/static/no.png') {
			return url;
		}

		const value = util.config.host + url;
		return value;
	},

	// 检测头像链接是否可用，不可用展示默认头像
	headlink(imgurl) {
		// return new Promise(function(resolve, reject) {
		// 	var ImgObj = new Image();
		// 	ImgObj.src = imgurl;
		// 	ImgObj.onload = function(res) {
		// 		resolve(res);
		// 	}
		// 	ImgObj.onerror = function(err) {
		// 		reject(err)
		// 	}
		// }).catch((e) => {})
		//判断链接是否存在
		/* var ImgObj = new Image();
		ImgObj.src = imgurl;
		console.log(ImgObj); */
		/* if (ImgObj.fileSize > 0 || (ImgObj.width > 0 && ImgObj.height > 0)) {
			return
		} else {
			return 'https://api.youdaike.com/static/index/logo_default.png'
		} */
		if (imgurl != null && imgurl != undefined) {
			return imgurl
		} else {
			return 'https://api.youdaike.com/static/index/logo_default.png'
		}
	},

	// 预览图片
	previewImage(res, param) {

		if (!res) {
			console.log('预览缺少res', res);
			return
		}

		if (!param) {
			param = {}
		}

		// 配置参数
		param.index ? param.index : 0; // 下标
		// param.http ? param.http : ''; // 域名

		param.loop ? param.loop : false;
		param.type ? param.type : 'default';


		// 必须为 数组
		if (res instanceof Array) {
			var urls = res;
		} else {
			var urls = res.split(',')
		}

		// 加域名
		urls.forEach((item, index) => {
			urls[index] = util.getImage(item);
		});

		// 预览图片
		uni.previewImage({
			current: param.index, // 为当前显示图片的链接/索引值，不填或填写的值无效则为 urls 的第一张。App，current为必填。不填会报错
			urls: urls,
			// 图片指示器样式，可取值："default" - 底部圆点指示器； "number" - 顶部数字指示器； "none" - 不显示指示器。
			indicator: param.type,
			loop: param.loop, // 是否可循环预览，默认值为 false
			longPressActions: { //长按图片显示操作菜单，如不填默认为保存相册
				itemList: ['发送给朋友', '保存图片', '收藏'],
			}
		});
	},
	//转化数量
	convertToShort(number, type) {
		if (!number) {
			return 0
		} else {
			number = Number(number); // 将数据转换为数字类型
			if (number >= 10000000) {
				return (number / 10000000).toFixed(number % 10000000 !== 0 ? 1 : 0) + 'kw';
			} else if (number >= 10000) {
				return (number / 10000).toFixed(number % 10000 !== 0 ? 1 : 0) + 'w';
			} else if (number >= 1000) {
				if (type) {
					return number.toString()
				}
				return (number / 1000).toFixed(number % 1000 !== 0 ? 1 : 0) + 'k';
			} else {
				return number.toString();
			}
		}
	},
	// 复制
	copy(data) {
		uni.setClipboardData({
			data,
			success: () => {
				util.alert('微信号复制成功，请添加发布人微信进行联系~')
			}
		});
	},

	// 拨打电话
	makePhoneCall(Phone) {
		if (!Phone) {
			console.log('makePhoneCall 拨打电话缺少参数 phone');
			return
		}
		uni.makePhoneCall({
			phoneNumber: Phone,
		});
	},


	// 上传图片
	upImg(all, obj) {

		// 图片计数
		const count = obj.count ? obj.count : 1;
		if (!obj.arr) {
			util.alert('缺少参数 arr ')
			return
		}

		// 目前数量
		let number = all[obj.arr].length;
		if (number > count - 1) {
			util.alert('最多上传' + count + '张图片')
			return
		}

		// 还可上传数量
		let min = count - number;

		// 选择
		uni.chooseImage({
			count,
			success: rs => {

				rs.tempFiles.forEach(item => {
					if (item.size / 1024 / 1024 > 10) {
						util.alert('上传图片不允许超过10M');
						return
					}
					util.upload({
						file: item.path,
						success: rs => {
							console.log(
								'后续逻辑没写哈 只有code == 200 的逻辑'
							);
							'upload上传完毕，请去util完善函数'
							if (rs.code == 200) {
								if (!min) {
									util.alert('最多上传' +
										count +
										'张图片'
									)
									return
								}
								all[obj.arr].push(
									rs
									.fileName
								);
								min--;
								return obj
									.success ?
									obj.success(
										all[obj
											.arr
										]
									) :
									() => {}; // 输出
							}
						}
					})
				});
			},
		})
	},


	// 上传文件
	upfile(all, obj) {
		/**
		 * 名称			是否必填		注释
		 * obj.type
		 *		all		从所有文件选择
		 *		video	只能选择视频文件
		 *		image	只能选择图片文件	
		 * obj.arr		true		需要操作的数组
		 * obj.count	false		上传图片数 默认 1
		 * obj.success	false		执行成功返回的方法return修改的对象
		 */

		//用来验证的后缀，如果还有其它格式，可以添加在right_type;
		var right_type = new Array("avi", "wmv", "mpg", "mpeg", "mov", "ram", "swf", "mp4", "mp3", "wma",
			"rm",
			"rmvb", "flv", "mkv")

		// 图片计数
		const count = obj.count ? obj.count : 1;
		const type = obj.type ? obj.type : 'image';
		if (!obj.arr) {
			util.alert('缺少参数 arr ')
			return
		}

		// 目前数量
		let number = all[obj.arr].length;
		if (number > count - 1) {
			util.alert('最多上传数量：' + count)
			return
		}

		// 还可上传数量
		let min = count - number;

		// 选择
		wx.chooseMessageFile({
			count,
			type,
			success: rs => {

				rs.tempFiles.forEach(item => {

					/*只获取后缀*/
					let path = item.path.substring(item.path.lastIndexOf(
						".") + 1);

					if (!right_type.includes(path) && type == 'audio') {
						this.alert('请上传音频文件')
						return
					}

					if (item.size / 1024 / 1024 > 10) {
						util.alert('上传文件不允许超过10M');
						return
					}
					util.upload({
						file: item.path,
						success: rs => {
							// console.log('后续逻辑没写哈 只有code == 200 的逻辑');'upload上传完毕，请去util完善函数'
							if (rs.code == 200) {
								if (!min) {
									util.alert('最多上传数量：' +
										count
									)
									return
								}
								all[obj.arr].push(
									rs
									.fileName
								);
								min--;
								return obj
									.success ?
									obj.success(
										all[obj
											.arr
										]
									) :
									() => {}; // 输出
							}
						}
					})
				});
			},
		})
	},


	/**
	 * 上传视频
	 * @param {Object}	obj		操作视频的对象键值
	 */
	upVideo(obj) {
		/**
		 * 名称			是否必填		注释
		 * obj.obj		true		需要操作的对象
		 * obj.key		true		操作对象的键值
		 * obj.type		false		1 单	 2群
		 * obj.count	false		视频计数
		 * obj.success	false		执行成功返回的方法return修改的对象
		 */

		// 格式化默认值
		// 视频计数
		const count = obj.count ? obj.count : 9
		// 类型
		obj.type = obj.type ? obj.type : 1
		// 键值
		const key = obj.key
		// 对象
		const wrap = obj.obj

		// 如果没有
		if (!wrap[key]) {
			wrap[key] = obj.type == 2 ? [] : ""
		}

		// 判断是否对群
		if (obj.type == 2) {
			// 判断剩余视频上传个数
			if (wrap[key].length >= count) {
				// 弹窗提示
				util.alert('上传的视频数量已达上限')
				return;
			};
		}

		// 选择视频
		uni.chooseVideo({
			// compressed: true,
			success(rs) {
				// 调用上传视频
				util.upload({
					file: rs.tempFilePath,
					success(res) {
						// 上传成功
						if (res.code == 1) {
							// 判断类型
							if (obj.type == 2) {
								// 添加长路径视频
								wrap[key].push(res.data.fullurl)
							} else {
								// 添加长路径视频
								wrap[key] = res.data.fullurl
							}

							// 更新变量
							obj.obj = Object.assign({}, wrap)

							// 输出
							obj.success ? obj.success(obj.obj) : ''
						} else {
							util.alert(rs.msg)
						}
					},
				})
			},
			fail(rs) {
				if (rs.errMsg == "chooseImage:fail cancel") {
					// 取消选择
				}
			},
		})
	},


	// 文件上传
	uploadFiles(obj) {
		/**
		 * 参数名称		传参类型		默认值		备注
		 * limit		Number		100			文件限制大小 单位mb
		 * count		Number		1			文件计数
		 * success								成功执行函数
		 */

		// 最大单位限制 m兆字节
		const limit = obj.limit ? obj.limit : 100
		// 默认值
		const count = obj.count ? obj.count : 1
		// #ifdef MP-WEIXIN
		// 从微信聊天里面选择文件
		wx.chooseMessageFile({
			count,
			type: 'file',
			success(rs) {
				// 遍历数组
				rs.tempFiles.forEach((e, i) => {
					// 文件大小
					if (e.size > (limit * 1024 * 1024)) {
						util.alert('上传的文件大于' + limit + 'm')
						return
					}
					// 上传文件
					util.upload({
						file: e.path,
						success(res) {
							if (res.code == 1) {
								// 执行方法
								obj.success ? obj.success(
									res) : ''
							} else {
								util.alert(rs.msg)
							}
						},
					})
				})
			},
		})
		// #endif
		// #ifndef MP-WEIXIN
		util.alert('暂未开放')
		// #endif
	},

	// 选择位置
	chooseLocation(cb) {
		// 获取权限
		uni.authorize({
			// 地理位置
			scope: 'scope.userLocation',
			// 成功
			success(res) {
				// 选择地址
				uni.chooseLocation({
					success(rs) {
						return cb(rs) ? cb(rs) : ''
					},
					fail(rs) {
						// 弹窗提示
						util.alert('您取消了选择')
					}
				})
			},
			// 失败
			fail(res) {
				// 弹窗
				util.alert({
					value: "小程序需要获取您的位置",
					success(rs) {
						if (rs.confirm) {
							// 打开设置
							uni.openSetting()
						}
					}
				})
			}
		})
	},



	// 微信小程序授权
	weChatAuthorize(obj) {
		// 成功
		return new Promise((resolve, reject) => {
			// 是否在微信小程序限制范围内
			if (!['scope.userInfo', 'scope.userLocation', 'scope.userLocationBackground',
					'scope.address',
					'scope.record', 'scope.writePhotosAlbum', 'scope.camera',
					'scope.invoice',
					'scope.invoiceTitle', 'scope.werun'
				].includes(obj.scope)) {
				// 限制
				resolve({
					msg: '不在限制范围内',
				})
				return
			}

			// 授权
			uni.authorize({
				scope: obj.scope,
				success: rs => {
					// 成功
					resolve(rs)
				},
				fail: err => {
					// 失败
					reject(err)

					// 弹窗提示
					util.alert({
						title: '系统提示',
						value: obj.txt,
						success: rs => {
							if (rs.confirm) {
								// 打开微信权限设置
								uni.openSetting()
							}
						},
					})
				},
			})
		})
	},




	// 清除登录状态
	logout() {

		// 把vuex的值改成未登陆的状态
		store.dispatch('setdataAsync', {
			key: 'userinfo',
			info: {
				avatar: '/static/no.png',
				nickname: '未登录',
			},
		})
		// 删除缓存的用户信息
		// uni.removeStorageSync('userinfo')
		uni.removeStorageSync('token')
	},

	// 获取当前地址位置信息
	getaddressinfo(obj = {}) {
		obj.type = obj.type ? obj.type : '';
		return new Promise((resolve, reject) => {
			// #ifdef APP || H5
			if (obj.type == 'mp') {
				// 打开地图 选择位置
				uni.chooseLocation({
					success: res => {
						obj.success ? obj.success(res) : function() {};
						resolve(res);
					},
					fail: rs => {
						console.log('获取位置报错', rs.errMsg);
						reject(rs);
					}
				});
			} else {
				// 获取当前经纬度
				uni.getLocation({
					type: 'wgs84',
					success: res => {
						console.log(res);
						resolve(res);
						obj.success ? obj.success(res) : function() {};
					},
					fail: rs => {
						reject(rs);
						console.log('获取位置报错', rs.errMsg);
					}
				});
			}
			// #endif

			// #ifdef MP-WEIXIN
			// 提前向用户发起授权请求。调用后会立刻弹窗询问用户是否同意授权小程序使用某项功能或获取用户的某些数据，但不会实际调用对应接口。如果用户之前已经同意授权，则不会出现弹窗，直接返回成功。如果用户之前拒绝了授权，此接口会直接进入失败回调，一般搭配uni.getSetting和uni.openSetting使用。
			uni.authorize({
				scope: 'scope.userLocation',
				success: () => {
					switch (obj.type) {
						case 'mp':
							// 打开地图 选择位置
							uni.chooseLocation({
								success: res => {
									obj.success ?
										obj
										.success(
											res
										) :
										function() {};
									resolve(
										res
									);
								},
								fail: rs => {
									console.log('获取位置报错',
										rs
										.errMsg
									);
									reject(rs);
								}
							});
							break;

						default:
							// 获取当前经纬度
							uni.getLocation({
								type: 'wgs84',
								success: res => {
									obj.success ?
										obj
										.success(
											res
										) :
										function() {};
									resolve(
										res
									);
								},
								fail: rs => {
									console.log('获取位置报错',
										rs
										.errMsg
									);
									reject(rs);
								}
							});
							break;
					}
				},
				fail() {
					// 调起客户端小程序设置界面，返回用户设置的操作结果。
					uni.openSetting();
				}
			})
			// #endif
		})
	},

	toLlogin() { // 跳转登录
		util.alert('登录解锁更多有趣内容！')
		setTimeout(() => {
			uni.navigateTo({
				url: '/pagesB/login/Login',
			})
		}, 200)
	},

	userToLogin(shareUserId) { // 用户分享跳转登录
		util.alert('登录解锁更多有趣内容！')
		setTimeout(() => {
			uni.navigateTo({
				url: '/pagesA/login/login?shareUserId=' + shareUserId,
			})
		}, 200)
	},

	// 
	down_image(url) {
		uni.getSetting({
			success(res) {

				if (Object.keys(res.authSetting).length > 0) {
					//判断是否有相册权限
					if (res.authSetting['scope.writePhotosAlbum'] == undefined) {
						//打开设置权限
						uni.authorize({
							scope: 'scope.userLocation',
							success() {
								console.log('设置权限', res.authSetting)
							}
						})
					} else {
						if (!res.authSetting['scope.writePhotosAlbum']) {
							//打开设置权限
							uni.authorize({
								scope: 'scope.userLocation',
								success() {
									console.log('设置权限', res.authSetting)
								}
							})
						}
					}
				} else {
					return
				}
			}
		})

		uni.downloadFile({
			url,
			success: (res) => {
				if (res.statusCode === 200) {
					uni.saveImageToPhotosAlbum({
						filePath: res.tempFilePath,
						success: function() {
							util.alert('保存成功')
						},
						fail: (err) => {
							console.log('errr', err)
						}
					})
				} else {
					util.alert(res.msg)
				}
			}
		})
	},

	/**
	 * 权限效验
	 * @param {Object} field
	 */
	authCheck(field) {
		return new Promise((resolve, reject) => {
			var userinfo = uni.getStorageSync("userinfo");
			switch (field) {
				case "mobile":
					// if (!userinfo[field]) {
					// 	util.alert('请先绑定手机号码');
					// 	resolve(false);
					// 	setTimeout(() => {
					// 		uni.navigateTo({
					// 			url: "/pagesB/login/Login",
					// 		})
					// 	}, 1500);
					// 	return;
					// }
					resolve(true);
					break;
				default:
					resolve(false);
					break;
			}
		})
	},
}